# 题目1：字符串处理题目描述：编写一个函数reverse_words，该函数接收一个字符串作为参数，
# 并返回一个新的字符串，其中字符串中的每个单词顺序被反转，但单词内的字符顺序保持不变。
print("reverse_words")
def reverse_words(s:str):
    return " ".join(s.split(" ")[::-1])
print(reverse_words("the quick brown fox"))

# 题目2：列表操作题目描述：编写一个函数rotate_list，该函数接收一个列表和一个整数n作为参数，
# 并返回一个新的列表，该列表是将原列表向右旋转n个位置后的结果。
print("rotate_list")
def rotate_list(lst:list,n):
    for i in range(0,n):
        tem=lst.pop()
        lst.insert(0,tem)
    print(lst)
rotate_list([1, 2, 3, 4, 5], n=2)

# 题目3：字典操作题目描述：编写一个函数flatten_dict，
# 该函数接收一个嵌套的字典作为参数，并返回一个新的字典，其中所有的键值对都被展平成单层的键值对，
# 键为路径形式的字符串。
print("flatten_dict")
def flatten_dict(d:dict,parent_key="",sep="."):
    items=[]
    for k,v in d.items():
        new_key=f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v,dict):
            items.extend(flatten_dict(v,new_key,sep=sep).items())
        else:
            items.append((new_key,v))
    return dict(items)
print(flatten_dict({"a": {"b": {"c": 1}}}))

# 题目4：数据结构应用题目描述：编写一个函数find_duplicate_in_array，该函数接收一个整数列表作为参数，
# 并返回列表中第一个重复的元素。如果列表没有重复元素，则返回None。
print("find_duplicate_in_array")
def find_duplicate_in_array(lst:list):
    for l in lst:
        if lst.count(l)>1:
            return l
    return None
print(find_duplicate_in_array([1, 2, 3, 2, 4]))

# 题目5：文件处理题目描述：编写一个函数compress_file，该函数接收一个文件路径作为参数，
# 并压缩该文件的内容，即将文件中连续重复的字符替换为字符加上重复次数，并将压缩后的结果保存到新的文件中。
with open(file="./file01/test001.txt",mode="r",encoding="utf-8") as file:
    lines = file.readlines()
    tem=""
    for line in lines:
        print(line.strip())
        tem=tem+line.strip()
    print(tem)
    import collections
    print(dict(collections.Counter(tem)))
print("compress_file")
def compress_file(input_path,out_path):
    tem=""
    with open(file=input_path,mode="r",encoding="utf-8") as file:
        lines=file.readlines()
        for line in lines:
            tem=tem+line.strip()
    import collections
    tem_dict=dict(collections.Counter(tem))
    compress_content=""
    for k,v in tem_dict.items():
        compress_content=compress_content+str(k)+str(v)
    print(compress_content)
    with open(file=out_path,mode="w",encoding="utf-8") as file:
        file.write(compress_content)
    print(f"file compressed successfully and saved to {out_path}")
compress_file("./file01/test001.txt","./file01/compressed.txt")

# 题目6：字符串处理题目描述：编写一个函数is_palindrome，该函数接收一个字符串作为参数，并返回一个布尔值，
# 表示该字符串是否为回文（正读和反读都一样的字符串
print("is_palindrome")
def is_palindrome(s:str):
    return s==s[::-1]
print(is_palindrome("racecar"))
print(is_palindrome("hello"))

# 题目7：列表操作题目描述：编写一个函数flatten_nested_list，该函数接收一个可能包含嵌套列表的列表作为参数，
# 并返回一个新的扁平化的列表，其中所有嵌套层次被展开。
print("flatten_nested_list")
res=[]
def flatten_nested_list(lst):
    for l in lst:
        if isinstance(l,list):
            flatten_nested_list(l)
        else:
            res.append(l)
flatten_nested_list([1, [2, [3, 4], 5], 6])
print(res)

# 题目8：字典操作题目描述：编写一个函数sort_dict_by_value_desc，该函数接收一个字典作为参数，并返回一个新的字典，
# 其中的键值对按照值从大到小排序。
print("sort_dict_by_value_desc")
def sort_dict_by_value_desc(d:dict):
    # from operator import itemgetter
    # return dict(sorted(d.items(),key=itemgetter(1),reverse=True))
    return dict(sorted(d.items(),key=lambda item:item[1],reverse=True))

print(sort_dict_by_value_desc({"apple": 2, "banana": 3, "cherry": 1}))

# 题目9：数据结构应用题目描述：编写一个函数find_longest_consecutive_sequence，
# 该函数接收一个整数列表作为参数，并返回列表中最长的连续递增子序列的长度
print("find_longest_consecutive_sequence")
def find_longest_consecutive_sequence(lst:list):
    if not lst:
        return 0
    max_length=1
    current_length=1
    for i in range(1,len(lst)):
        if lst[i]>lst[i-1]:
            current_length=current_length+1
            max_length=max(max_length,current_length)
        else:
            current_length=1
    return max_length
print(find_longest_consecutive_sequence([1, 2, 3, 2, 3, 4, 5]))


print(98220-103226+7087-7113+5502-5240+12006-11845)
